FEXPNetworkInterface.h

Go to the documentation of this file.

// © FEXP, FEXPEnterprise Solver, Ing. Vaclav Rek
// 
// Compiler must support C++ ver.14 and later
#ifndef _CFEXPNETWORKINTERFACE_H_
#define _CFEXPNETWORKINTERFACE_H_
#include "FEXPCommon.h"
#include "FEXPDataContainer.h"
#include "FEXPSetting.h"

#define LOCALHOST              "127.0.0.1"           // localhost IP adress
#define DFNETPORT                    27015/*20248*/  // chosen default port
#define DEFAULT_SERVER_NODE_ID         0x0

class ICFEXPNetBase
{
public:
  virtual ~ICFEXPNetBase() { }
  // pure virtual member functions
  virtual size_t GetId()    const = 0;
  virtual void   SetId(size_t id) = 0;
protected:
  // [no protected members] -----------------------------
private:
  // [no private members  ] -----------------------------
};


class ICFEXPNetNodeConnection
  : public ICFEXPNetBase
{
public:
  ICFEXPNetNodeConnection(size_t node_id, std::string server_ip, size_t port);
  virtual ~ICFEXPNetNodeConnection() { }
  // override pure virtual base function
  virtual size_t GetId()    const override { return _node_ID; }
  virtual void   SetId(size_t id) override { _node_ID = id;   }
  // member functions                                      
  std::string GetServerNodeIP() { return _server_IP; }
  size_t      GetCommPort    () { return _port;      }

  // pure virtual member functions
  virtual void Run  () = 0;
  virtual void Close() = 0;
protected:
  // additional structures for handling network communication
  std::atomic_bool _connection_start;

  template<typename TInp, typename TFunc>
  std::function<TFunc()> get_thread_functor(std::function<TFunc(TInp)> thread_fce, std::function<TInp()> input);
private:
  size_t      _node_ID;
  std::string _server_IP;
  size_t      _port;
};

// member functions
//--------------------------------------------------------------------------------------
template<typename TInp, typename TFunc>
std::function<TFunc()> ICFEXPNetNodeConnection::get_thread_functor(
  std::function<TFunc(TInp)> thread_fce, std::function<TInp()> input)
//--------------------------------------------------------------------------------------
{
  return [thread_fce, input] { return thread_fce(input()); };
}

class CEFEXPNETProtocol
{
public:
  enum EMainNETCommunicationPoint
  {
    eIdInit                 , 
    eInitialize             , 
    eGetStabilDt            , 
    eSetStabilDt            , 
    eGetResults             ,
    eSetResults             ,
    eGetBoundBox            ,
    eSetBoundBox            ,
    eGetBoundBoxId          ,
    eSetBoundBoxId          ,
    eGetMacroModel          ,
    eSetMacroModel          ,
    eGetMacroModelId        ,
    eSetMacroModelId        ,
    eGetMacroModelCalcData  ,
    eSetMacroModelCalcData  ,
    eGetMacroModelCalcDataId,
    eSetMacroModelCalcDataId,
    eGetIsEndCalc           ,
    eSetIsEndCalc           ,
    //------------------------------------------------------------------------------------//
    eContinue               , // message info about calculation continuation
    //------------------------------------------------------------------------------------//
    eReceived               , // message info about successfull data receiving
    eEndDataBlock           , // message info about ending of block of data sending
    //------------------------------------------------------------------------------------//
    eDataKey                , // data key
    eData                   , // data
    //------------------------------------------------------------------------------------//
    //------------------------------------------------------------------------------------//
    eError                  , // some error
    //------------------------------------------------------------------------------------//
    //------------------------------------------------------------------------------------//
    eMessageCount
  };
  static std::string                GetNetMessage(EMainNETCommunicationPoint comm);
  static EMainNETCommunicationPoint GetNetMessage(std::string comm);

  enum ENETSynchronization
  {
    eStartPoint        ,
    eBeforeClientUpdate,
    eClientUpdate      ,
    eAfterClientUpdate ,
    eCheckCalcEnd      ,
    eEndPoint          ,
    eStartNewTimeStep  ,
    eResults           ,
    eStabilityControl  ,
    eDataExchange      ,
    eEndLoop           ,
    eSynchrCount
  };

  enum ENETServerThreadMesage
  {
    eInit        ,
    eBoundingBox ,
    eRuntimeInit ,
    eContinueProc,
    eStep        ,
    eCalcResults ,
    eEnd         ,
    eThrdMsgCount
  };
protected:
  using t_MessageMap = std::map<EMainNETCommunicationPoint, std::string>;
  static t_MessageMap MESSAGES;
private:
  // [no private members  ] -----------------------------
};

using t_ENetMessage = CEFEXPNETProtocol::EMainNETCommunicationPoint;
using t_ENetSynStgs = CEFEXPNETProtocol::ENETSynchronization;
using t_ENetThrdMsg = CEFEXPNETProtocol::ENETServerThreadMesage;


class ICFEXPNetClientNodeService
{
public:
  // pure virtual member functions for calculation instruction reading and setting
  virtual Ptr<std::map<size_t, Ptr<t_ModelData>>> ReadInstruction()                                      = 0;
  virtual void                                    SendInstruction(size_t message, Ptr<t_ModelData> data) = 0;

  // pure virtual member functions for handling with macro model data
  virtual Ptr<t_ModelData>    GetMacroModelData()                                                     = 0;
  virtual void                AddMacroModelData(const t_ModelDataKey & key, Ptr<t_ModelDataDta> data) = 0;
  virtual Ptr<t_ModelDataDta> GetMacroModelData(const t_ModelDataKey & key)                           = 0;

  static t_ModelData & GetReadModelData(Ptr<std::map<size_t, Ptr<t_ModelData>>> data, size_t key);
protected:
  // [no protected members] -----------------------------
private:
  // [no private members  ] -----------------------------
};


class CFEXPNetServerClientCalcData
{
public:
  CFEXPNetServerClientCalcData(Ptr<CFEXPSolverConfigSetting> setting)
    : _server_setting(setting), _data_for_send_prepared(false), _data_received_prepared(false) { }
  // data prepared flag
  std::atomic_bool _data_for_send_prepared;
  std::atomic_bool _data_received_prepared;
  // current data to send to client node
  t_ModelData CURRENT_DATA_FOR_SEND;
  // current data received from client node
  t_ModelData CURRENT_DATA_RECEIVED;
  // data for print out
  t_ModelData CURRENT_DATA_FOR_POUT;
  // data transfer info
  // --> model data to send to server
  std::vector<size_t>                     MODEL_DATA_GET;
  // --> model data transfer from server to client
  std::vector<std::tuple<size_t, size_t>> MODEL_DATA_SET;
  // macro model data
  t_ModelData INPUT_MACRO_MODEL_DATA;
  t_ModelData RUNTIME_CLC_MACRO_DATA;

  Ptr<t_ModelDataDta> GetModelData(size_t key) { return _server_setting->GetFileContent()[key]; }
protected:
  Ptr<CFEXPSolverConfigSetting> _server_setting;
private:
  // [no privat members   ] -----------------------------
};

using t_NetCalcData = CFEXPNetServerClientCalcData;


template<typename TSocket>
class ICFEXPNetServerClientNode
  : public ICFEXPNetNodeConnection
{
public:
  ICFEXPNetServerClientNode(TSocket socket, std::string client_ip, size_t node_id, std::string server_ip, size_t port,
    std::function<t_ENetThrdMsg     (size_t, size_t                                       )> message_gttr,
    std::function<bool              (size_t, size_t                                       )> message_lchr,
    std::function<void              (size_t, size_t                        , t_ENetThrdMsg)> message_sttr,
    std::function<Ptr<t_NetCalcData>(size_t                                               )> clcdata_gttr,
    std::function<void              (size_t                                               )> state_update,
    std::function<bool              (size_t                                               )> synchronizer,
    std::function<void              (size_t, t_fexpcommon_ct                              )> dtmacro_sttr,
    std::function<void              (size_t, Ptr<CFEXGeomTools::t_BoundBox>, size_t       )> mdmacro_sttr)
    : ICFEXPNetNodeConnection(node_id, server_ip, port), _socket(socket), _client_ip(client_ip),
    _thread_message_gttr(message_gttr),
    _thread_message_lchr(message_lchr),
    _thread_message_sttr(message_sttr),
    _thread_clcdata_gttr(clcdata_gttr),
    _thread_state_update(state_update),
    _thread_synchronizer(synchronizer),
    _thread_dtmacro_sttr(dtmacro_sttr),
    _thread_mdmacro_sttr(mdmacro_sttr) { }
  
protected:
  TSocket     _socket;
  std::string _client_ip;

  // providers to server data
  std::function<t_ENetThrdMsg     (size_t, size_t                                      )> _thread_message_gttr;
  std::function<bool              (size_t, size_t                                      )> _thread_message_lchr;
  std::function<void              (size_t, size_t                       , t_ENetThrdMsg)> _thread_message_sttr;
  std::function<Ptr<t_NetCalcData>(size_t                                              )> _thread_clcdata_gttr;
  std::function<void              (size_t                                              )> _thread_state_update;
  std::function<bool              (size_t                                              )> _thread_synchronizer;
  std::function<void              (size_t, t_fexpcommon_ct                             )> _thread_dtmacro_sttr;
  std::function<void              (size_t, Ptr<CFEXGeomTools::t_BoundBox>, size_t      )> _thread_mdmacro_sttr;
private:
  // [no private members  ] -----------------------------
};


/*template<typename TClient>
class ICFEXPNetServerConnectionProvider
  : public ICFEXPNetNodeConnection
{
public:
  ICFEXPNetServerConnectionProvider(size_t node_id, std::string server_ip, size_t port,
    std::function<t_ENetThrdMsg     (size_t, size_t                                       )> message_gttr,
    std::function<bool              (size_t, size_t                                       )> message_lchr,
    std::function<void              (size_t, size_t                        , t_ENetThrdMsg)> message_sttr,
    std::function<Ptr<t_NetCalcData>(size_t                                               )> clcdata_gttr,
    std::function<void              (size_t                                               )> state_update,
    std::function<bool              (size_t                                               )> synchronizer,
    std::function<void              (size_t, t_fexpcommon_ct                              )> dtmacro_sttr,
    std::function<void              (size_t, Ptr<CFEXGeomTools::t_BoundBox>, size_t       )> mdmacro_sttr)
    : ICFEXPNetNodeConnection(node_id, server_ip, port)
    _thread_message_gttr(message_gttr),
    _thread_message_lchr(message_lchr),
    _thread_message_sttr(message_sttr),
    _thread_clcdata_gttr(clcdata_gttr),
    _thread_state_update(state_update),
    _thread_synchronizer(synchronizer),
    _thread_dtmacro_sttr(dtmacro_sttr),
    _thread_mdmacro_sttr(mdmacro_sttr)
  { }
  virtual ~ICFEXPNetServerConnectionProvider() { }

  // pure virtual member functions
  virtual Ptr<TClient> TryConnectNewClient (size_t id) = 0;
  virtual bool         GetIsClientDisconect()          = 0;
protected:
  // providers to server data
  std::function<t_ENetThrdMsg     (size_t, size_t                                      )> _thread_message_gttr;
  std::function<bool              (size_t, size_t                                      )> _thread_message_lchr;
  std::function<void              (size_t, size_t                       , t_ENetThrdMsg)> _thread_message_sttr;
  std::function<Ptr<t_NetCalcData>(size_t                                              )> _thread_clcdata_gttr;
  std::function<void              (size_t                                              )> _thread_state_update;
  std::function<bool              (size_t                                              )> _thread_synchronizer;
  std::function<void              (size_t, t_fexpcommon_ct                             )> _thread_dtmacro_sttr;
  std::function<void              (size_t, Ptr<CFEXGeomTools::t_BoundBox>, size_t      )> _thread_mdmacro_sttr;
private:
  // [no private members  ] -----------------------------
};*/

#endif // !_CFEXPNETWORKINTERFACE_H_